home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Aminet 21
/
Aminet 21 (1997)(GTI - Schatztruhe)[!][Oct 1997].iso
/
Aminet
/
comm
/
bbs
/
cit_src_7H21.lha
/
mr.c
< prev
next >
Wrap
C/C++ Source or Header
|
1997-07-27
|
7KB
|
375 lines
/**
Citadel Mail Snooper Utility Version 1.00
**/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
/*
* #define DEBUG
*/
void StopDecode(void);
void Process(char *file);
void GetStr(FILE * fd, char *buf);
void StartDecode( int (*func)() );
int Decode(int c);
int moo(int c);
int Decode2(int val);
#define TRUE 1
#define FALSE 0
int main(int, char **);
int main(int argc, char **argv)
{
FILE *fp;
char line[80];
int i, j, k;
fprintf(stderr," Citadel Mail Identifier Version 1.00\n");
if( argc > 1 )
{
for( i=1; i<argc; i++)Process(argv[i]);
}
else
{
if( (fp=fopen("map.sys", "r")) == NULL )
{
fprintf(stderr,"unable to open map.sys\n");
fprintf(stderr,"This utility must be run from the DOMAINAREA\n");
}
else
{
while( fgets(line,80,fp) )
{
i = atoi(line);
for( j=2; line[j] != ' ' && j < 80; j++);
for( ; line[j] == ' ' && j < 80; j++); /* find start of number */
j = atoi(&line[j]);
for(k=0; k<j; k++)
{
sprintf(line,"%d/%d",i,k);
Process(line);
};
};
fclose(fp);
};
};
return 0;
}
void strip(char *p)
{
int i = strlen(p);
for(i--; i> 0 && (p[i] == ' '|| p[i]=='\0'); i--);
p[i+1]='\0';
}
char author[50];
char date[50];
char node[50];
char to[50];
char domain[50];
#define STARTING 0
#define COLLECTING 1
#define EATING 2
int state = STARTING;
void Process(char *file)
{
char id[21];
int c;
char name[21];
FILE *fd;
author[0] = 0;
date[0] = 0;
to[0] = 0;
node[0] = 0;
domain[0] = 0;
state = STARTING;
if ((fd = fopen(file, "rb")) == NULL)return;
GetStr(fd, id);
GetStr(fd, name);
StartDecode(moo);
while ((c = getc(fd)) != EOF)
{
Decode(c);
}
StopDecode();
fclose(fd);
strip(author);
strip(date);
strip(to);
strip(node);
strip(domain);
printf("%s from %s@%s_%s to %s@%s\n", date, author, node,domain, to,
name);
}
void GetStr(FILE * fd, char *buf)
{
int c,
i = 0;
while ((c = getc(fd)) != 0 && c != EOF)
{
buf[i++] = c;
}
buf[i] = 0;
}
int moo(c)
int c;
{
static int ind;
static char *str;
if (state == STARTING)
{
ind = 0;
switch (c)
{
case 'A':
str = author;
state = COLLECTING;
break;
case 'D':
str = date;
state = COLLECTING;
break;
case 'T':
str = to;
state = COLLECTING;
break;
case 'N':
str = node;
state = COLLECTING;
break;
case 'X':
str = domain;
state = COLLECTING;
break;
default:
state = EATING;
}
}
else if (state == EATING)
{
if (c == 0)
{
state = STARTING;
}
}
else
{
if (c == 0)
{
state = STARTING;
}
str[ind++] = c;
}
return TRUE;
}
#define CAPS 0
#define NO_CAPS 1
#define NUMERICS 2
#define SPEC_CHARS 3
#define FINISHED 4 /*
* finished with encoded data
*/
#define NO_SET 5 /*
* an initial value
*/
#define COMP_SPACE 26 /*
* universal
*/
#define ZERO_COMP 16
#define RET_COMP 17
#ifdef NEEDED
struct
{
char Set, /*
* code set
*/
CompValue; /*
* position in code set
*/
}
compress[] =
{
{ 0, 0 }, { 2, 10 }, { 2, 11 }, { 2, 12 }, { 2, 13 }, /* * ' ' - '$' */
{ 2, 14 }, { 2, 15 }, { 2, 16 }, { 2, 17 }, { 2, 18 }, /* * '%' - ')' */
{ 2, 19 }, { 2, 20 }, { 2, 21 }, { 2, 22 }, { 2, 23 }, /* * '*' - '.' */
{ 2, 24 }, { 2, 0 }, { 2, 1 }, { 2, 2 }, { 2, 3 }, /* * '/' - '3' */
{ 2, 4 }, { 2, 5 }, { 2, 6 }, { 2, 7 }, { 2, 8 }, /* * '4' - '8' */
{ 2, 9 }, { 2, 25 }, { 3, 0 }, { 3, 1 }, { 3, 2 }, /* * '9' - '=' */
{ 3, 3 }, { 3, 4 }, { 3, 5 }, { 0, 0 }, { 0, 1 }, /* * '>' - 'B' */
{ 0, 2 }, { 0, 3 }, { 0, 4 }, { 0, 5 }, { 0, 6 }, /* * 'C' - 'G' */
{ 0, 7 }, { 0, 8 }, { 0, 9 }, { 0, 10 }, { 0, 11 }, /* * 'H' - 'L' */
{ 0, 12 }, { 0, 13 }, { 0, 14 }, { 0, 15 }, { 0, 16 }, /* * 'M' - 'Q' */
{ 0, 17 }, { 0, 18 }, { 0, 19 }, { 0, 20 }, { 0, 21 }, /* * 'R' - 'V' */
{ 0, 22 }, { 0, 23 }, { 0, 24 }, { 0, 25 }, { 3, 6 }, /* * 'W' - '[' */
{ 3, 7 }, { 3, 8 }, { 3, 9 }, { 3, 10 }, { 3, 11 }, /* * '\' - '`' */
{ 1, 0 }, { 1, 1 }, { 1, 2 }, { 1, 3 }, { 1, 4 }, /* * 'a' - 'e' */
{ 1, 5 }, { 1, 6 }, { 1, 7 }, { 1, 8 }, { 1, 9 }, /* * 'f' - 'i' */
{ 1, 10 }, { 1, 11 }, { 1, 12 }, { 1, 13 }, { 1, 14 }, /* * 'j' - 'o' */
{ 1, 15 }, { 1, 16 }, { 1, 17 }, { 1, 18 }, { 1, 19 }, /* * 'p' - 't' */
{ 1, 20 }, { 1, 21 }, { 1, 22 }, { 1, 23 }, { 1, 24 }, /* * 'u' - 'y' */
{ 1, 25 }, { 3, 12 }, { 3, 13 }, { 3, 14 }, { 3, 15 } /** 'z' - '' */};
#endif
static char Numerics[] =
{
'0', '1', '2', '3', '4',
'5', '6', '7', '8', '9',
'!', '\"', '#', '$', '%',
'&', '\'', '(', ')', '*',
'+', ',', '-', '.', '/',
':'
};
static char SpecChars[] =
{
';', '<', '=', '>', '?',
'@', '[', '\\', ']', 0x5e,
'_', '`', '{', '|', '}',
' ', 0, '\r'
};
static char CurSet;
static int OB,
ThisVal,
NB;
int (*OutFunc) ();
void StartDecode(func)
int (*func) ();
{
ThisVal = 0;
CurSet = NO_SET;
OutFunc = func;
NB = 5;
}
void
StopDecode()
{
}
int
Decode(c)
int c;
{
static int mask[] =
{
0, 1, 3, 7, 0xf, 0x1f
};
int AB;
if (CurSet == FINISHED)
return TRUE;
#ifdef DEBUG
fprintf(stderr, "decoding %x, ThisVal is currently %x\n", c, ThisVal);
#endif
if (!Decode2(c & mask[NB]))
return FALSE;
c >>= NB;
#ifdef DEBUG
fprintf(stderr, "c becomes %x\n", c);
#endif
AB = 8 - NB;
if (AB >= 5)
{
ThisVal = 0;
AB -= 5;
NB = 5;
if (!Decode2(c & mask[NB]))
return FALSE;
c >>= 5;
#ifdef DEBUG
fprintf(stderr, "c becomes %x\n", c);
#endif
}
NB = 5 - AB;
ThisVal = c;
return TRUE;
}
int Decode2(val)
int val;
{
int toReturn;
char Used;
if (CurSet == FINISHED)
return TRUE;
ThisVal += (val << (5 - NB));
#ifdef DEBUG
fprintf(stderr, "ThisVal calculates to be %x, val is %x\n", ThisVal, val);
#endif
switch (ThisVal - 27)
{
case FINISHED:
#ifdef DEBUG
fprintf(stderr, "Finished found.\n");
#endif
case CAPS:
case NO_CAPS:
case NUMERICS:
case SPEC_CHARS:
CurSet = ThisVal - 27;
Used = TRUE;
toReturn = TRUE;
break;
default:
Used = FALSE;
}
/*
* Discard if no set defined.
*/
if (!Used)
{
if (CurSet == NO_SET)
toReturn = TRUE;
/*
* True for any valid code set
*/
else if (ThisVal == COMP_SPACE)
toReturn = (*OutFunc) (' ');
else
switch (CurSet)
{
case CAPS:
toReturn = (*OutFunc) ('A' + ThisVal);
break;
case NO_CAPS:
toReturn = (*OutFunc) ('a' + ThisVal);
break;
case NUMERICS:
toReturn = (*OutFunc) (Numerics[ThisVal]);
break;
case SPEC_CHARS:
toReturn = (*OutFunc) (SpecChars[ThisVal]);
break;
}
}
return toReturn;
}